const path = require('path')
const fs = require('fs')
/**
 * 模拟 mock 数据
 */
const mockData = require('./defaultMocks');

/**
 * 根据默认值类型返回默认值
 * @param {string} type - 默认值类型
 * @returns {*} - 默认值
 */
function getDefaultValue(type) {
    switch (type.toLowerCase()) {
        case 'array':
            return [];
        case 'object':
            return {};
        case 'string':
            return '';
        case 'number':
            return 0;
        default:
            return null;
    }
}

/**
 * 处理 sub 操作：取子集
 * @param {Array} data - 数据数组
 * @param {string} start - 开始下标
 * @param {string} end - 结束下标
 * @returns {Array} - 子集
 */
function handleSubOperation(data, start, end) {
    const startIndex = parseInt(start, 10);
    const endIndex = parseInt(end, 10);
    if (!Array.isArray(data) || isNaN(startIndex) || isNaN(endIndex)) {
        return data;
    }
    return data.slice(startIndex, endIndex + 1);
}

/**
 * 处理 random 操作：随机取指定数量的元素
 * @param {Array} data - 数据数组
 * @param {string} count - 随机取的数量
 * @returns {Array} - 随机子集
 */
function handleRandomOperation(data, count) {
    const num = parseInt(count, 10);
    if (!Array.isArray(data) || isNaN(num) || num <= 0) {
        return data;
    }
    const shuffled = [...data].sort(() => 0.5 - Math.random());
    return shuffled.slice(0, Math.min(num, data.length));
}

/**
 * 处理 mock 数据
 * @param {string} type - 默认值类型
 * @param {string} key - mock 数据中的 key
 * @param {string[]} params - 操作参数
 * @returns {*} - 处理后的结果
 */
function processMockData(type, key, params, moudleNames = []) {
    var mockDatas = {};
    
    moudleNames.reverse().forEach((mname)=>{
        const moudleName = mname
        const mockpath = path.join(__dirname, `${moudleName}.js`);
        const exift = fs.existsSync(mockpath);
        const tmockData = exift ? require(`./${moudleName}.js`) : {};

        mockDatas = Object.assign({}, mockDatas, tmockData)
    })
        
    // 从 mock 数据中获取值，如果不存在则根据类型返回默认值
    const data = mockDatas[key] !== undefined ? mockDatas[key] : getDefaultValue(type);

    // 如果没有参数，直接返回数据
    if (params.length === 0) {
        return JSON.stringify(data);
    }

    // 根据第一个参数（操作类型）处理数据
    const operation = params[0].toLowerCase();

    if (operation === 'sub' && params.length >= 3) {
        return JSON.stringify(handleSubOperation(data, params[1], params[2]));
    } else if (operation === 'random' && params.length >= 2) {
        return JSON.stringify(handleRandomOperation(data, params[1]));
    }

    // 如果操作不匹配，返回原始数据
    return JSON.stringify(data);
}

/**
 * 替换字符串中的 _WPCC_xxx("xxx:xxx(xxx, xxx, xxx...)") 为 mock 数据
 * @param {string} input - 输入字符串
 * @returns {string} - 替换后的字符串
 */
function replaceWpccWithMockData(input, moudleNames) {
    // 正则表达式：
    // 捕获处理方法、默认值类型、key 和括号内的参数
    const regex = /_WPCC_[a-zA-Z0-9_]+?\("([a-z]+):([a-zA-Z0-9._]+)(?:\(([^()]*)\))?"\)/g;

    return input.replace(regex, (match, type, key, params) => {
        // params 是括号内的参数字符串，例如 "sub,1,3" 或 "random,2"
        // 如果没有参数，则 params 为 undefined
        const paramList = params ? params.split(',').map(p => p.trim()) : [];

        // console.log(moudleName)
        // 处理 mock 数据
        const result = processMockData(type, key, paramList, moudleNames);

        return result;
    });
}

module.exports = replaceWpccWithMockData
// // 测试代码
// const testString = `
// Some text before _WPCC_GET_DATAS("array:products(sub,1,3)") some text in between
// Another call _WPCC_FETCH_DATA("array:products(random,2)") end text
// Direct output _WPCC_TEST("string:greeting()")
// Number output _WPCC_NUM("number:count()")
// Unknown key _WPCC_UNKNOWN("array:unknown()")`;

// const result = replaceWpccWithMockData(testString);
// console.log(result);